home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Aminet 21
/
Aminet 21 (1997)(GTI - Schatztruhe)[!][Oct 1997].iso
/
Aminet
/
comm
/
bbs
/
cit_src_7H21.lha
/
aff.c
< prev
next >
Wrap
C/C++ Source or Header
|
1997-07-27
|
11KB
|
450 lines
/*
* Aff.C
*
* Automatic File Forwarding utility.
*/
/*
* History
*
* 90May15 HAW V1 Created.
*/
/*
* Contents
*
* crashout() general crash routine
* InitSystem() open up appropriate data base files
* main() main manager
* ParseFileMap() reads in CtdlAff.Sys
* EatMapLine() eats a line from a file map
* RewriteFileMap() writes out the updated file map
* WriteFileList() work fn that writes out a ctdlaff.sys entry
* SystemWrite() work fn writes out the indicated system
* SendThemFiles() setts up the .sfl files
* UpdateSFLs() updates the sfl file for the given system
* WriteSFL() This will write the .sfl file
* CopyToTemp() copies a name to the temporary list
* ShowArguments() usage
* FileCmp() helps find the string in a list
* CheckSystems() used to help search for a given system in list
*/
#include "ctdl.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <time.h>
#include <dos.h>
#include <proto/exec.h>
#include <dos/dos.h>
#include <pragmas/dos_pragmas.h>
#include "exec/memory.h"
#include "exec/ports.h"
#include "exec/exec.h"
#ifndef NO_STAT
#include "sys\stat.h"
#endif
long getdateof(char *file);
extern FILE *upfd;
extern CONFIG cfg;
extern NetBuffer netBuf;
extern int thisNet;
extern FILE *netfl;
extern NetTable *netTab;
extern char *READ_ANY, *WRITE_ANY, *WRITE_TEXT;
void InitSystem(void);
void ShowArguments(void);
void ParseFileMap(void);
void SendThemFiles(void);
void RewriteFileMap(void);
/*
* crashout()
*
* This is general crash routine. Needed by getNet, etc.
*/
void crashout(str)
char *str;
{
printf(str);
exit(1);
}
/*
* InitSystem()
*
* This is used to open up appropriate data base files, and initialize buffers.
*/
void InitSystem()
{
SYS_FILE name;
/* Open database files. */
makeSysName(name, "ctdlnet.sys", &cfg.netArea);
openFile(name, &netfl);
/* Now initialize data buffers. */
initNetBuf(&netBuf);
}
/*
* main()
*
* The main manager for Aff.
*/
int main(int, char **);
int main(argc, argv)
int argc;
char **argv;
{
printf("AFF %s\nAutomatic File Forwarding\n%s\n", VERSION_NAME, COPYRIGHT);
if (access(LOCKFILE, 0) != ERROR) {
printf("Please do not run AFF using Outside Commands.\n");
exit(1);
}
if (argc > 1) {
ShowArguments();
exit(1);
}
if (!readSysTab(FALSE, FALSE)) {
printf("Couldn't read system table.\n");
exit(1);
}
InitSystem(); /* Open needed data files */
ParseFileMap();
RewriteFileMap(); /* rewrite updated CtdlAff.Sys next */
SendThemFiles(); /* now send them files (if any) */
writeSysTab();
return 0;
}
#define FILE_NAME 0
#define SYSTEM_NAME 1
#define NO_FILE_NAME 2
char MapState = FILE_NAME;
void *EatMapLine(char *line);
void *CheckSystems();
SListBase Files = { NULL, NULL, NULL, NULL, EatMapLine };
SListBase Systems = { NULL, CheckSystems, NULL, NULL, NULL };
/* this structure is used to rebuild ctdlaff.sys */
typedef struct {
char *Filename;
long Date;
SListBase SystemList;
} FileList;
/* this structure is used in SystemList, above */
typedef struct {
char *Systemname;
long Date;
} SystemRec;
/* this structure is used for efficient updates of *.sfl */
typedef struct {
char *Systemname;
SListBase NewFiles; /* but this is just a list of strings */
} SystemUpdate;
/*
* ParseFileMap()
*
* This function will read in CtdlAff.Sys.
*/
void ParseFileMap()
{
SYS_FILE fn;
makeSysName(fn, "ctdlaff.sys", &cfg.netArea);
if (!MakeList(&Files, fn, NULL))
crashout("Couldn't find CtdlAff.Sys.");
}
/*
* EatMapLine()
*
* This function will eat a line from a file map. Actions depend on
* MapState:
*
* FILE_NAME: looking for a filename to parse.
* SYSTEM_NAME: looking for a system to send file to.
* NO_FILE_NAME: File for this doesn't exist, so ignore entries.
*
* File is formatted:
* <filename>
* <system name>:<number>
* <system name>:<number>
* ...
* <blank line>
* <filename>
*/
void *EatMapLine(char *line)
{
static FileList *data; /* keep static so we know what's current*/
char *colon, work[200];
SystemRec *sysdata;
SystemUpdate *sysupdate, *System;
#ifndef NO_STAT
struct stat buf;
#endif
switch (MapState) {
case FILE_NAME:
if (strLen(line) == 0) return NULL; /* discard blank lines */
if (access(line, 0) != 0) { /* if file doesn't exist*/
MapState = NO_FILE_NAME; /* then don't process */
printf("Warning: file %s not found.\n", line);
}
else MapState = SYSTEM_NAME; /* file exists */
data = GetDynamic(sizeof *data);
data->Filename = strdup(line);
if (MapState == SYSTEM_NAME) {
#ifndef NO_STAT
stat(line, &buf);
data->Date = buf.st_mtime;
#else
data->Date = getdateof(line);
#endif
}
InitListValues(&data->SystemList, NULL, NULL, NULL, NULL);
return data;
case NO_FILE_NAME:
if (strLen(line) == 0) { /* blank line, return to normal */
MapState = FILE_NAME;
return NULL;
}
if ((colon = strchr(line, ':')) != NULL) {
*colon++ = 0;
NormStr(colon); /* kill leading spaces on date */
NormStr(line); /* kill trailing spaces */
sysdata = GetDynamic(sizeof *sysdata);
sysdata->Systemname = strdup(line);
sysdata->Date = atol(colon);
AddData(&data->SystemList, sysdata, NULL, FALSE);
}
return NULL;
case SYSTEM_NAME:
if (strLen(line) == 0) { /* blank line, return to normal */
MapState = FILE_NAME;
}
else {
if ((colon = strchr(line, ':')) != NULL) {
*colon++ = 0;
NormStr(colon); /* kill leading spaces on date */
NormStr(line); /* kill trailing spaces */
sysdata = GetDynamic(sizeof *sysdata);
sysupdate = GetDynamic(sizeof *sysupdate);
sysdata->Systemname = sysupdate->Systemname = strdup(line);
sysdata->Date = atol(colon);
AddData(&data->SystemList, sysdata, NULL, FALSE);
if (data->Date > sysdata->Date) {
if ((System = SearchList(&Systems, sysdata->Systemname))
== NULL) {
System = sysupdate;
InitListValues(&System->NewFiles,NULL,NULL,NULL,NULL);
AddData(&Systems, System, NULL, FALSE);
}
else free(sysupdate);
strcpy(work, data->Filename);
AddData(&System->NewFiles, strdup(work), NULL, FALSE);
if (searchNameNet(line, &netBuf) != ERROR)
sysdata->Date = data->Date; /* update record */
}
}
}
return NULL; /* always return NULL here */
default: crashout("Parsing failure!");
}
return NULL;
}
static FILE *fd;
/*
* RewriteFileMap()
*
* This function writes out the file map.
*/
void RewriteFileMap()
{
SYS_FILE fn;
void WriteFileList();
makeSysName(fn, "ctdlaff.sys", &cfg.netArea);
if ((fd = fopen(fn, WRITE_TEXT)) == NULL)
crashout("Couldn't update CtdlAff.Sys!");
RunList(&Files, WriteFileList);
fclose(fd);
}
/*
* WriteFileList()
*
* This is a work fn that writes out a ctdlaff.sys entry.
*/
void WriteFileList(FileList *data)
{
void SystemWrite();
fprintf(fd, "%s\n", data->Filename);
RunList(&data->SystemList, SystemWrite);
fprintf(fd, "\n"); /* blank line separator */
}
/*
* SystemWrite()
*
* This work fn writes out the indicated system to fd.
*/
void SystemWrite(SystemRec *data)
{
fprintf(fd, " %s : %ld\n", data->Systemname, data->Date);
}
/*
* SendThemFiles()
*
* This function manages setting up the .sfl files.
*/
void SendThemFiles()
{
void UpdateSFLs();
RunList(&Systems, UpdateSFLs);
}
void *FileCmp();
SListBase TempList = { NULL, FileCmp, NULL, NoFree, NULL };
/*
* UpdateSFLs()
*
* This updates the sfl file for the given system. It works to ensure
* duplicates are not accidentally sent - that explains the complexity.
*/
void UpdateSFLs(SystemUpdate *data)
{
void CopyToTemp(), WriteSFL();
int slot;
SYS_FILE fn;
char temp[10], realname[100];
if ((slot = searchNameNet(data->Systemname, &netBuf)) == ERROR) {
printf("Warning: no system '%s' known.\n", data->Systemname);
return;
}
printf("System %s:", data->Systemname);
RunList(&data->NewFiles, CopyToTemp);
printf(".\n");
sPrintf(temp, "%d.sfl", slot);
makeSysName(fn, temp, &cfg.netArea);
if ((upfd = safeopen(fn, READ_ANY)) != NULL) {
while (getSLNet(realname, upfd)) {
/* NormalName(&buf, realname); */
AddData(&TempList, strdup(realname), NULL, TRUE);
}
fclose(upfd);
unlink(fn);
}
if ((upfd = safeopen(fn, WRITE_ANY)) != NULL) {
RunList(&TempList, WriteSFL);
fclose(upfd);
}
netBuf.nbflags.send_files = TRUE;
putNet(slot, &netBuf);
KillList(&TempList);
}
/*
* WriteSFL()
*
* This will update the .sfl file.
*/
void WriteSFL(char *name)
{
struct fl_send buf;
void SetBuffer(char *name, struct fl_send *buf);
SetBuffer(name, &buf);
putSLNet(buf, upfd);
}
/*
* CopyToTemp()
*
* This function will copy a name to the temporary list with no dups.
*/
void CopyToTemp(char *name)
{
printf(" %s", name);
AddData(&TempList, name, NULL, TRUE);
}
/*
* ShowArguments()
*
* This will show off arguments.
*/
void ShowArguments()
{
printf("usage: Aff\n");
}
/*
* FileCmp()
*
* This function helps find the designated string in a list of strings.
*/
void *FileCmp(char *n1, char *n2)
{
if (strCmpU(n1, n2) == SAMESTRING) return n1;
return NULL;
}
/*
* CheckSystems()
*
* This function is used to help search for a given system in a list.
*/
void *CheckSystems(SystemRec *s, char *t)
{
if (stricmp(s->Systemname, t) == SAMESTRING) return s;
return NULL;
}
long getdateof(char *file)
{
long thetime;
struct FileInfoBlock *info;
info = (struct FileInfoBlock *)calloc(1, sizeof(struct FileInfoBlock));
if( dfind(info,file,0) == 0 )
{
thetime = info->fib_Date.ds_Days*24*3600;
thetime+= info->fib_Date.ds_Minute;
}
else thetime = 0;
free(info);
return thetime;
}